#include "types.h"
#include "global.h"
#include "board.h"
#include "keypaddef.h"
#include "menudef.h"
#include "menuTextProp.h"


//--Eson Start----------------------------------
BYTE *NullText( void )
{
    return 0;
}

BYTE *NetAddrText( void )
{
    return strNetAddrM0[UserPrefLanguage];
}
BYTE *BriteContText( void )
{
    return strBriteContM0[UserPrefLanguage];
}
BYTE *AutoAdjustText( void )
{
    return strAutoAdjustM0[UserPrefLanguage];
}
BYTE *InputSourceText( void )
{
    return strInputSourceM0[UserPrefLanguage];
}
BYTE *ColorSettingsText( void )
{
    return strColorSettingsM0[UserPrefLanguage];
}
BYTE *_3DText( void )
{
    return str3DM0[UserPrefLanguage];
}
BYTE *DisplaySettingsText( void )
{
    return strDisplaySettingsM0[UserPrefLanguage];
}
BYTE *OtherSettingsText( void )
{
    return strOtherSettingsM0[UserPrefLanguage];
}
BYTE *InformationText( void )
{
    return strInformationM0[UserPrefLanguage];
}

BYTE *NoSignalText( void )
{
    return strNoSignalM2[UserPrefLanguage];
}

BYTE *CableNotConnectedText( void )
{
    return strCableNotConnectedM4[UserPrefLanguage];
}

BYTE *OutofRangeText( void )
{
    return strOutofRangeM5[UserPrefLanguage];
}

BYTE *ResetProgressText( void )
{
    return strResetProgressM7[UserPrefLanguage];
}

BYTE *AutoAdjustProgressText( void )
{
    return strAutoAdjustProgessM8[UserPrefLanguage];
}

BYTE *InputStatusText( void )
{
    if (1)//Autoflag
    {
        if(CURRENT_INPUT_IS_VGA())
            return strAutoAnalogM10[UserPrefLanguage];
        else if(CURRENT_INPUT_IS_DVI())
            return strAutoDigitalM10[UserPrefLanguage];
        else if(CURRENT_INPUT_IS_HDMI())
            return strAutoHDMIM10[UserPrefLanguage];
        else if(CURRENT_INPUT_IS_DISPLAYPORT())
            return strAutoDPM10[UserPrefLanguage];
        else
            return strAutoMHLM10[UserPrefLanguage];
    }
    else
    {
        if(CURRENT_INPUT_IS_VGA())
            return strAnalogInputM10[UserPrefLanguage];
        else if(CURRENT_INPUT_IS_DVI())
            return strDigitalInputM10[UserPrefLanguage];
        else if(CURRENT_INPUT_IS_HDMI())
            return strHDMIInputM10[UserPrefLanguage];
        else if(CURRENT_INPUT_IS_DISPLAYPORT())
            return strDP_InputM10[UserPrefLanguage];
        else
            return strMHL_InputM10[UserPrefLanguage];
    }
}


BYTE *BrightnessText( void )
{
    return strBrightnessM101[UserPrefLanguage];
}
BYTE *ContrastText( void )
{
    return strContrastM101[UserPrefLanguage];
}
BYTE *DCRText( void )
{
    return strDCRM101[UserPrefLanguage];
}
#if ENABLE_DLC
BYTE *DLCText( void )
{
    return strDLCM101[UserPrefLanguage];
}
#endif

#if ENABLE_DPS
BYTE *DPSText( void )
{
    return strDPSM101[UserPrefLanguage];
}
BYTE *DPSStatusText( void )
{
    if (UserprefDPSMode)
        return strOnM101[UserPrefLanguage];
    else
        return strOffM101[UserPrefLanguage];
}
#endif
#if ENABLE_DSC
BYTE *DSCText( void )
{
    return strDSCM101[UserPrefLanguage];
}
BYTE *DSCStatusText( void )
{
    if (UserprefDSCMode)
        return strOnM101[UserPrefLanguage];
    else
        return strOffM101[UserPrefLanguage];
}
#endif

BYTE *DCRStatusText( void )
{
    if (UserPrefDcrMode)
        return strOnM101[UserPrefLanguage];
    else
        return strOffM101[UserPrefLanguage];
}
#if ENABLE_DLC
BYTE *DLCStatusText( void )
{
    if (UserprefDLCMode)
        return strOnM101[UserPrefLanguage];
    else
        return strOffM101[UserPrefLanguage];
}
#endif

BYTE *OnM101Text( void )
{
    return strOnM101[UserPrefLanguage];
}
BYTE *OffM101Text( void )
{
    return strOffM101[UserPrefLanguage];
}


BYTE *ColorTempText( void )
{
    return strColorTempM102[UserPrefLanguage];
}
BYTE *CsRGBText( void )
{
    return strsRGBM102[UserPrefLanguage];
}
BYTE *C5700KText( void )
{
    return str5700KM102[UserPrefLanguage];
}
BYTE *C6500KText( void )
{
    return str6500KM102[UserPrefLanguage];
}
BYTE *C9300KText( void )
{
    return str9300KM102[UserPrefLanguage];
}
BYTE *UserColorText( void )
{
    return strUserColorM102[UserPrefLanguage];
}
BYTE *RedText( void )
{
    return strRedM102[UserPrefLanguage];
}
BYTE *GreenText( void )
{
    return strGreenM102[UserPrefLanguage];
}
BYTE *BlueText( void )
{
    return strBlueM102[UserPrefLanguage];
}
BYTE *HueText( void )
{
    return strHueM102[UserPrefLanguage];
}
BYTE *SaturationText( void )
{
    return strSaturationM102[UserPrefLanguage];
}
BYTE *ColorModeText( void )
{
    return strColorModeM102[UserPrefLanguage];
}
BYTE *OffM102Text( void )
{
    return strOffM102[UserPrefLanguage];
}
BYTE *EnhanceText( void )
{
    return strEnhanceM102[UserPrefLanguage];
}
BYTE *DemoText( void )
{
    return strDemoM102[UserPrefLanguage];
}
#if ENABLE_SUPER_RESOLUTION
BYTE *SuperResolutionText( void )
{
    return strSuperResolutionM102[UserPrefLanguage];
}
BYTE *WeakText( void )
{
    return strWeakM102[UserPrefLanguage];
}
BYTE *MiddleText( void )
{
    return strMiddleM102[UserPrefLanguage];
}
BYTE *StrongText( void )
{
    return strStrongM102[UserPrefLanguage];
}

BYTE *SuperResolutionStatusText( void )
{
    if( (UserPrefSuperResolutionMode % SRMODE_Nums)== SRMODE_STRONG)
        return strStrongM102[UserPrefLanguage];
    else if( (UserPrefSuperResolutionMode % SRMODE_Nums)== SRMODE_MIDDLE)
        return strMiddleM102[UserPrefLanguage];
    else if( (UserPrefSuperResolutionMode % SRMODE_Nums)== SRMODE_WEAK)
        return strWeakM102[UserPrefLanguage];
    else
        return strOffM102[UserPrefLanguage];
}
#endif
BYTE *ColorTempStatusText( void )
{
    if( UserPrefColorTemp == CTEMP_Warm1 )
    {
        return str5700KM102[UserPrefLanguage];
    }
    else if( UserPrefColorTemp == CTEMP_Normal )
    {
        return str6500KM102[UserPrefLanguage];
    }
    else if( UserPrefColorTemp == CTEMP_Cool1 )
    {
        return str9300KM102[UserPrefLanguage];
    }
    else if( UserPrefColorTemp == CTEMP_SRGB )
    {
        return strsRGBM102[UserPrefLanguage];
    }
    else //if( UserPrefColorTemp == CTEMP_USER )
    {
        return strUserColorM102[UserPrefLanguage];
    }
}
BYTE *ColorModeStatusText( void )
{
    if (1)
        return strOffM102[UserPrefLanguage];
    else if (1)
        return strEnhanceM102[UserPrefLanguage];
    else
        return strDemoM102[UserPrefLanguage];
}

BYTE *AutoSelectText( void )
{
    return strAutoSelectM103[UserPrefLanguage];
}
#if (INPUT_TYPE!=INPUT_1A)
BYTE *DigitalPort0Text( void )
{
	#if (CHIP_ID==CHIP_TSUMC || CHIP_ID==CHIP_TSUMD || CHIP_ID==CHIP_TSUMJ || CHIP_ID==CHIP_TSUM9 || CHIP_ID==CHIP_TSUMF)
		if (Input_DVI_C1==Input_Digital||Input_DVI_C2==Input_Digital||Input_DVI_C3==Input_Digital)
			return strDVIM103[UserPrefLanguage];
		else if (Input_HDMI_C1==Input_Digital||Input_HDMI_C2==Input_Digital||Input_HDMI_C3==Input_Digital)
			return strHDMIM103[UserPrefLanguage];
		else if (Input_Displayport_C2==Input_Digital||Input_Digital2==Input_Digital)
			return strDisplayPortM103[UserPrefLanguage];
	#elif (CHIP_ID==CHIP_TSUMV || CHIP_ID==CHIP_TSUMB ||CHIP_ID==CHIP_TSUMY ||CHIP_ID==CHIP_TSUM2 ||CHIP_ID==CHIP_TSUMU)
		#if (DVI_PORT&TMDS_PORT_A)
			return strDVIM103[UserPrefLanguage];
		#elif (HDMI_PORT&TMDS_PORT_A)
			return strHDMIM103[UserPrefLanguage];
		#else
			return strDisplayPortM103[UserPrefLanguage];		
		#endif
	#else 
		return 0;
	#endif
}
#endif
#if (INPUT_TYPE==INPUT_1A2D || INPUT_TYPE ==INPUT_1A2H || INPUT_TYPE ==INPUT_2A2D || INPUT_TYPE ==INPUT_1A1D1H || INPUT_TYPE ==INPUT_1A1D1DP || INPUT_TYPE ==INPUT_1A1H1DP || INPUT_TYPE ==INPUT_1A2C || INPUT_TYPE ==INPUT_1A3C || INPUT_TYPE == INPUT_1A1D1H1DP)
BYTE *DigitalPort1Text( void )
{
	#if (CHIP_ID==CHIP_TSUMC || CHIP_ID==CHIP_TSUMD || CHIP_ID==CHIP_TSUMJ || CHIP_ID==CHIP_TSUM9 || CHIP_ID==CHIP_TSUMF)
		if (Input_DVI_C1==Input_Digital2||Input_DVI_C2==Input_Digital2||Input_DVI_C3==Input_Digital2)
		{
			return strDVIM103[UserPrefLanguage];
		}
		else if (Input_HDMI_C1==Input_Digital2||Input_HDMI_C2==Input_Digital2||Input_HDMI_C3==Input_Digital2)
		{
			return strHDMIM103[UserPrefLanguage];
		}
		else if (Input_Displayport_C2==Input_Digital2||Input_Displayport_C2==Input_Digital2)
		{
			return strDisplayPortM103[UserPrefLanguage];
		}
	#elif (CHIP_ID==CHIP_TSUMV || CHIP_ID==CHIP_TSUMB ||CHIP_ID==CHIP_TSUMY ||CHIP_ID==CHIP_TSUM2 ||CHIP_ID==CHIP_TSUMU)
		#if (DVI_PORT&TMDS_PORT_B)
			return strDVIM103[UserPrefLanguage];
		#elif (HDMI_PORT&TMDS_PORT_B)
			return strHDMIM103[UserPrefLanguage];
		#else
			return strDisplayPortM103[UserPrefLanguage];
		#endif
	#else 
		return 0;
	#endif	
}
#endif

#if (INPUT_TYPE ==INPUT_1A3C || INPUT_TYPE == INPUT_1A1D1H1DP)
BYTE *DigitalPort2Text( void )
{
	#if (CHIP_ID==CHIP_TSUMC || CHIP_ID==CHIP_TSUMD || CHIP_ID==CHIP_TSUMJ || CHIP_ID==CHIP_TSUM9 || CHIP_ID==CHIP_TSUMF)
		if (Input_DVI_C1==Input_Digital3||Input_DVI_C2==Input_Digital3||Input_DVI_C3==Input_Digital3)
			return strDVIM103[UserPrefLanguage];
		else if (Input_HDMI_C1==Input_Digital3||Input_HDMI_C2==Input_Digital3||Input_HDMI_C3==Input_Digital3)
			return strHDMIM103[UserPrefLanguage];
		else if (Input_Displayport_C2==Input_Digital3||Input_Displayport_C3==Input_Digital3)
			return strDisplayPortM103[UserPrefLanguage];
	#elif (CHIP_ID==CHIP_TSUMV || CHIP_ID==CHIP_TSUMB ||CHIP_ID==CHIP_TSUMY ||CHIP_ID==CHIP_TSUM2 ||CHIP_ID==CHIP_TSUMU)
		#if (DVI_PORT&TMDS_PORT_C)
			return strDVIM103[UserPrefLanguage];
		#elif (HDMI_PORT&TMDS_PORT_C)
			return strHDMIM103[UserPrefLanguage];
		#else
			return strDisplayPortM103[UserPrefLanguage];
		#endif
	#else 
		return 0;
	#endif	
}
#endif	

BYTE *VGAText( void )
{
    return strVGAM103[UserPrefLanguage];
}


BYTE *_3DFormatText( void )
{
    return str3DFormatM104[UserPrefLanguage];
}
BYTE *_3DAutoText( void )
{
    return strAutoM104[UserPrefLanguage];
}
BYTE *_3DSidebySideText( void )
{
    return strSidebySideM104[UserPrefLanguage];
}
BYTE *_3DTopandBottomText( void )
{
    return strTopandBottomM104[UserPrefLanguage];
}
BYTE *_2Dto3DText( void )
{
    return str2Dto3DM104[UserPrefLanguage];
}
BYTE *OnM104Text( void )
{
    return strOnM104[UserPrefLanguage];
}
BYTE *OffM104Text( void )
{
    return strOffM104[UserPrefLanguage];
}
BYTE *SeparationText( void )
{
    return strSeparationM104[UserPrefLanguage];
}
BYTE *DepthText( void )
{
    return strDepthM104[UserPrefLanguage];
}
BYTE *_3DFormatStatusText( void )
{
    if (1)
        return strAutoM104[UserPrefLanguage];
    else if (1)
        return strSidebySideM104[UserPrefLanguage];
    else
        return strTopandBottomM104[UserPrefLanguage];
}
BYTE *_2Dto3DStatusText( void )
{
    if (1)
        return strOnM104[UserPrefLanguage];
    else
        return strOffM104[UserPrefLanguage];
}



BYTE *HPositionText( void )
{
    return strHPositionM105[UserPrefLanguage];
}
BYTE *VPositionText( void )
{
    return strVPositionM105[UserPrefLanguage];
}
#if ENABLE_SHARPNESS
BYTE *SharpnessText( void )
{
    return strSharpnessM105[UserPrefLanguage];
}
#endif
BYTE *ClockText( void )
{
    return strClockM105[UserPrefLanguage];
}
BYTE *PhaseText( void )
{
    return strPhaseM105[UserPrefLanguage];
}
#if Enable_Expansion
BYTE *AspectRatioText( void )
{
    return strAspectRatioM105[UserPrefLanguage];
}
BYTE *Ratio_FullText( void )
{
    return strFullM105[UserPrefLanguage];
}
BYTE *Ratio_43Text( void )
{
    return strRatio_43M105[UserPrefLanguage];
}
BYTE *Ratio_169Text( void )
{
    return strRatio_169M105[UserPrefLanguage];
}
BYTE *Ratio_11Text( void )
{
    return strRatio_11M105[UserPrefLanguage];
}
BYTE *Ratio_FixedInputRatioText( void )
{
    return strRatio_FixedInputRatioM105[UserPrefLanguage];
}
BYTE *Ratio_OverScanText( void )
{
    return strRatio_OverScanM105[UserPrefLanguage];
}
#endif
#if ENABLE_RTE
BYTE *OverdriveText( void )
{
    return strOverdriveM105[UserPrefLanguage];
}
BYTE *OverdriveStatusText( void )
{
     if (UserprefOverDriveSwitch)
        return strOnM105[UserPrefLanguage];
    else
        return strOffM105[UserPrefLanguage];
}
#endif
BYTE *GammaText( void )
{
    return strGammaM105[UserPrefLanguage];
}
BYTE *OnM105Text( void )
{
    return strOnM105[UserPrefLanguage];
}
BYTE *OffM105Text( void )
{
    return strOffM105[UserPrefLanguage];
}
#if Enable_Expansion
BYTE *AspectRatioStatusText( void )
{
		if (UserprefExpansionMode == Expansion_4_3)  //20150728
	        return strRatio_43M105[UserPrefLanguage];
		else if (UserprefExpansionMode == Expansion_16_9)
	        return strRatio_169M105[UserPrefLanguage];
		else if (UserprefExpansionMode == Expansion_1_1)
	        return strRatio_11M105[UserPrefLanguage];
		else if (UserprefExpansionMode == Expansion_KeepInputRatio)
	        return strRatio_FixedInputRatioM105[UserPrefLanguage];
		else if (UserprefExpansionMode == Expansion_OverScan)
	        return strRatio_OverScanM105[UserPrefLanguage];
		else
	        return strFullM105[UserPrefLanguage];
}
#endif

BYTE *GammaStatusText( void )
{
    if (UserPrefGamaOnOff)
        return strOnM105[UserPrefLanguage];
    else
        return strOffM105[UserPrefLanguage];
}


BYTE *OSDTransparencyText( void )
{
    return strOSDTransparencyM106[UserPrefLanguage];
}
BYTE *OSDHPositionText( void )
{
    return strOSDHPositionM106[UserPrefLanguage];
}
BYTE *OSDVPositionText( void )
{
    return strOSDVPositionM106[UserPrefLanguage];
}
BYTE *OSDTimeoutText( void )
{
    return strOSDTimeoutM106[UserPrefLanguage];
}

BYTE *LanguageText( void )
{
    return strLanguageM106[UserPrefLanguage];
}

BYTE *ChineseText( void )
{
    return strChineseM106[UserPrefLanguage];
}

BYTE *EnglishText( void )
{
    return strEnglishM106[UserPrefLanguage];
}

BYTE *OSDLanguageStatusText( void ) //add by smc.lmw 20160629
{
    if (UserPrefLanguage==LANG_English)
        return strEnglishM106[UserPrefLanguage];
	else 
        return strChineseM106[UserPrefLanguage];
	
}

#if AudioFunc
BYTE *VolumeText( void )
{
    return strVolumeM106[UserPrefLanguage];
}
#endif
#if ENABLE_OSD_ROTATION
BYTE *OSDRotateText( void )
{
    return strOSDRotateM106[UserPrefLanguage];
}
BYTE *OSDRotateStatusText( void )
{
    if (UserPrefOsdRotateMode==OSDRotateMenuItems_90)
        return strOSDRotate90M106[UserPrefLanguage];
	else
	#if defined(_OSD_ROTATION_180_)
    if (UserPrefOsdRotateMode==OSDRotateMenuItems_180)
        return strOSDRotate180M106[UserPrefLanguage];
	else
	#endif
	#if defined(_OSD_ROTATION_270_)
    if (UserPrefOsdRotateMode==OSDRotateMenuItems_270)
        return strOSDRotate270M106[UserPrefLanguage];
    else
	#endif
        return strOSDRotateOffM106[UserPrefLanguage];
}


BYTE *OSDRotateOFFText( void )
{
    return strOSDRotateOffM106[UserPrefLanguage];
}
BYTE *OSDRotate90Text( void )
{
    return strOSDRotate90M106[UserPrefLanguage];
}
#if defined(_OSD_ROTATION_180_)
BYTE *OSDRotate180Text( void )
{
    return strOSDRotate180M106[UserPrefLanguage];
}
#endif
#if defined(_OSD_ROTATION_270_)
BYTE *OSDRotate270Text( void )
{
    return strOSDRotate270M106[UserPrefLanguage];
}
#endif
#endif
BYTE *FactoryResetText( void )
{
    return strFactoryResetM106[UserPrefLanguage];
}

#if ENABLE_FREESYNC
BYTE *FreeSyncModeText( void )
{
    return strFREESYNCMODEM106[UserPrefLanguage];
}

BYTE *FreeSyncModeOFFText( void )
{
    return strFreeSyncOffM106[UserPrefLanguage];
}
BYTE *FreeSyncModeOnText( void )
{
    return strFreeSyncOnM106[UserPrefLanguage];
}

BYTE *FreeSyncModeStatusText( void )
{
    if (UserprefFreeSyncMode)
        return strFreeSyncOnM106[UserPrefLanguage];
	else
        return strFreeSyncOffM106[UserPrefLanguage];
}
#endif
BYTE *ResolutionText( void )
{
    return strResolutionM107[UserPrefLanguage];
}
BYTE *HFreqText( void )
{
    return strHFreqM107[UserPrefLanguage];
}
BYTE *VFreqText( void )
{
    return strVFreqM107[UserPrefLanguage];
}
BYTE *VTotalText( void )
{
    return strVTotalM107[UserPrefLanguage];
}

BYTE *ColorFormatText( void )
{
    return strColorFormatM102[UserPrefLanguage];
}
BYTE *ColorFormatStatusText( void )
{
    if (UserPrefInputColorFormat)
        return strYUVM102[UserPrefLanguage];
    else
        return strRGBM102[UserPrefLanguage];
}
BYTE *RGBText( void )
{
    return strRGBM102[UserPrefLanguage];
}
BYTE *YUVText( void )
{
    return strYUVM102[UserPrefLanguage];
}

BYTE *ColorFormatDisplayText( void )
{
    return strColorFormatM107[UserPrefLanguage];
}
BYTE *ColorFormatDisplayStatusText( void )
{
    if (UserPrefInputColorFormat)
        return strRGBM107[UserPrefLanguage];
    //else if (1)
    //    return strYUV444M107[UserPrefLanguage];
    else
        return strYUV422M107[UserPrefLanguage];
}
BYTE *xText( void )
{
    return strxM107[UserPrefLanguage];
}
BYTE *HzText( void )
{
    return strHzM107[UserPrefLanguage];
}
BYTE *KHzText( void )
{
    return strKHzM107[UserPrefLanguage];
}
BYTE *LineText( void )
{
    return strLineM107[UserPrefLanguage];
}


//--Eson End----------------------------------


BYTE *OsdLockText( void )
{
    return strOsdLockM56[UserPrefLanguage];
}

BYTE *Main_FText( void )//Added By SMC.LMW 20151118
{
    return strMain_F[UserPrefLanguage];
}

#if AudioFunc
#if (ENABLE_HDMI || ENABLE_DP_INPUT) && MS_DAC
BYTE *AudioSourceText( void )
{
    return strAudioSourceM58[UserPrefLanguage];
}
BYTE *AudioSourceValue( void )
{
    if( UserPrefAudioSource == 0)
    {
        return strLineInM58[UserPrefLanguage];
    }
    else //if( UserPrefAudioSource == 1)
    {
        return strDigitalM58[UserPrefLanguage];
    }
}
#endif
#endif
BYTE *ECOModeText( void )
{
    return strEcoModeM7[UserPrefLanguage];
}
BYTE *ECOModeValue( void )
{
    if( UserPrefECOMode == 0 )
    {
        return strECOStandM7[UserPrefLanguage];
    }
    else if( UserPrefECOMode == 1 )
    {
        return strECOTextM7[UserPrefLanguage];
    }
    else if( UserPrefECOMode == 2 )
    {
        return strECOInternetM7[UserPrefLanguage];
    }
    else if( UserPrefECOMode == 3 )
    {
        return strECOgameM7[UserPrefLanguage];
    }
    else if( UserPrefECOMode == 4 )
    {
        return strECOMovieM7[UserPrefLanguage];
    }
    else if( UserPrefECOMode == 5 )
    {
        return strECOSportM7[UserPrefLanguage];
    }
    else
    {
        return strECOStandM7[UserPrefLanguage];
    }
}



#if MWEFunction
BYTE *ColorBoostText( void )
{
    return strColorBoostM26[UserPrefLanguage];
}
BYTE *FullText( void )
{
    return strFullM26[UserPrefLanguage];
}
BYTE *NatureSkinText( void )
{
    return strNatureSkinM26[UserPrefLanguage];
}
BYTE *GreenFieldText( void )
{
    return strGreenFieldM26[UserPrefLanguage];
}
BYTE *SkyBlueText( void )
{
    return strSkyBlueM26[UserPrefLanguage];
}
BYTE *AutoDetectText( void )
{
    return strAutoDetectM26[UserPrefLanguage];
}
BYTE *DemoText( void )
{
    return strDemoM26[UserPrefLanguage];
}
BYTE *FreeColorFullModeText( void )
{
    if( FullEnhanceFlag )
    {
        return strOnM26[UserPrefLanguage];
    }
    else
    {
        return strOffM26[UserPrefLanguage];
    }
}
BYTE *FreeColorSkinProtectModeText( void )
{
    if( SkinFlag )
    {
        return strOnM26[UserPrefLanguage];
    }
    else
    {
        return strOffM26[UserPrefLanguage];
    }
}
BYTE *FreeColorGreenEnhanceModeText( void )
{
    if( GreenFlag )
    {
        return strOnM26[UserPrefLanguage];
    }
    else
    {
        return strOffM26[UserPrefLanguage];
    }
}
BYTE *FreeColorBlueEnhanceModeText( void )
{
    if( BlueFlag )
    {
        return strOnM26[UserPrefLanguage];
    }
    else
    {
        return strOffM26[UserPrefLanguage];
    }
}
BYTE *FreeColorAutoDetectModeText( void )
{
    if( ColorAutoDetectFlag )
    {
        return strOnM26[UserPrefLanguage];
    }
    else
    {
        return strOffM26[UserPrefLanguage];
    }
}
BYTE *FreeColorDemoModeText( void )
{
    if( DemoFlag )
    {
        return strOnM26[UserPrefLanguage];
    }
    else
    {
        return strOffM26[UserPrefLanguage];
    }
}
BYTE *PictureBoostText( void ) // picture boost
{
    return strPictureBoostM33[UserPrefLanguage];
}

BYTE *BF_FrameSizeText( void ) // frame size
{
    return strBF_FrameSizeM33[UserPrefLanguage];
}

BYTE *BF_BrightnessText( void ) // brightness
{
    return strBF_BrightnessM33[UserPrefLanguage];
}

BYTE *BF_ContrastText( void ) // contrast
{
    return strBF_ContrastM33[UserPrefLanguage];
}

BYTE *BFHPositionText( void )
{
    return strBF_HPositionM33[UserPrefLanguage];
}

BYTE *BFVPositionText( void )
{
    return strBF_VPositionM33[UserPrefLanguage];
}

BYTE *BF_SwitchText( void ) // switch(brith frame)
{
    return strBF_SwitchM33[UserPrefLanguage];
}

BYTE *BF_SwitchValueText( void )
{
    if( PictureBoostFlag )
    {
        return strOnM33[UserPrefLanguage];
    }
    else
    {
        return strOffM33[UserPrefLanguage];
    }
}
#endif


BYTE *ResetText( void )
{
    return strResetM49[UserPrefLanguage];
}


#if DDCCI_ENABLE
BYTE *DDCCIText( void )
{
    return strDDCCIM49[UserPrefLanguage];
}
BYTE *DDCCIValueText( void )
{
    if( DDCciFlag )
    {
        return strOnM49[UserPrefLanguage];
    }
    else
    {
        return strOffM49[UserPrefLanguage];
    }
}
#endif

#if ENABLE_OSD_3D_CONTROL
BYTE *To3DText( void )
{
    return str2DTo3DM13[UserPrefLanguage];
}
BYTE *To3DGameModeText (void)
{
    return strT3DGameModeM13[UserPrefLanguage];
}
BYTE *To3DValueText( void )
{
    if( UserPref2Dto3D )
    {
        return strOnM13[UserPrefLanguage];
    }
    else
    {
        return strOffM13[UserPrefLanguage];
    }
}
BYTE *To3DGameModeValueText( void )
{
    if( UserPref2Dto3DGameMode )
    {
        return strOnM13[UserPrefLanguage];
    }
    else
    {
        return strOffM13[UserPrefLanguage];
    }
}
BYTE *T3DGainText( void )
{
    return strT3DGainM13[UserPrefLanguage];
}
BYTE *T3DOffsetText( void )
{
    return strT3DOffsetM13[UserPrefLanguage];
}
#endif


#if ENABLE_DeBlocking
BYTE *DeBlockingText( void )
{
    return strDEBLOCKINGM13[UserPrefLanguage];
}
BYTE *DeBlockingValueText( void )
{
    if( UserPrefDeBlocking)
    {
        return strOnM13[UserPrefLanguage];
    }
    else
    {
        return strOffM13[UserPrefLanguage];
    }
}
#endif

BYTE *YesText( void )
{
    return strYesM49[UserPrefLanguage];
}

BYTE *NoText( void )
{
    return strNoM49[UserPrefLanguage];
}

BYTE *AutoColorPassText( void )
{
    return strAutoColorPassM57[UserPrefLanguage];
}
BYTE *AutoColorFailText( void )
{
    return strAutoColorFailM57[UserPrefLanguage];
}
BYTE *AutoColorMenuText( void )
{
    return strAutoColorM57[UserPrefLanguage];
}
#if 0
BYTE *FactoryIcon( void )
{
    return strFactoryIcon;
}
BYTE *OsdLockText( void )
{
    return strOsdLockText[UserPrefLanguage];
}
#endif
//======================================================================
